Linux Cubed Series 4: GNU Archives

home *** CD-ROM | disk | FTP | other *** search

/ Linux Cubed Series 4: GNU Archives / Linux Cubed Series 4 - GNU Archives.iso / gnu / descript < prev next >

Wrap

Text File | 1996-11-17 | 73.2 KB | 1,608 lines

-*- text -*- Last modified Thu Mar 21 18:57:21 1996 This is an incomplete and probably out-of-date list of all the packages distributed on prep.ai.mit.edu and its mirror sites with a brief description explaining what each one is. More information about these programs can typically be found in the GNU Bulletin. To receive a copy, write to gnu@prep.ai.mit.edu. Problems with the contents of this file (or problems pertaining to the packaging of these programs, e.g. if a file is corrupted) should be sent to gnu@prep.ai.mit.edu. Bug reports for the programs themselves should go to the appropriate address indicated in the instructions with that program and its source code. Because the unix `compress' utility is patented (by two separate patents, in fact), we cannot use it; it is not free software. Therefore, the GNU Project has chosen a new compression utility, `gzip', which is free of any known software patents and which tends to compress better anyway. Files compressed with this new compression program end in `.gz' (as opposed to `compress'-compressed files, which end in `.Z'). Gzip can uncompress `compress'-compressed files and SVR4 `pack' files (which end in `.z'). This is possible because the various decompression algorithms are not patented---only compression is. The gzip program is available from any GNU mirror site in shar, tar, or gzipped tar format (for those who already have a prior version of gzip and want faster data transmission). It works on virtually every unix system, MSDOS, OS/2, and VMS. Filenames below ending with "/" are directories. Other entries are plain files. COPYING-1.0 Version 1 of the GNU General Public License. COPYING-2.0 Version 2 of the GNU General Public License. COPYING.LIB-2.0 Version 2 of the GNU General Public Library License (there is no version 1). GNUinfo/ General files of interest about the GNU Project, most of them included in the GNU Emacs distribution. MailingListArchives/ Archives of the GNU mailing lists (most of which are also gatewayed to the various gnu.* newsgroups). MicrosPorts/ The GNU Project is not directly interested in integrating or maintaining ports of GNU software to many micro-computer systems, like Amiga's or MSDOS, because of limited resources. However, a few files with pointers to people who do maintain GNU software for these other systems are available in this directory. ProgramIndex A file with an index of which package each GNU program is in. The rest of this file is the articles ``Forthcoming GNUs'' and ``GNU Software'' from the most recent GNU's Bulletin. They contain descriptions of our software. For more infomation on FSF's tapes, diskettes and CD-ROMs see the file /pub/gnu/GNUinfo/ORDERS FTPable from prep.ai.mit.edu or one of its mirror sites. ---------------------------------------------------------------------- GNU Software ************ All our software is available via FTP; see *Note How to Get GNU Software::. We also offer software on various media and printed documentation: * *Note CD-ROMs::. * *Note Tapes::. * *Note MS-DOS Diskettes::. * *Note Documentation::, which includes manuals and reference cards. In these articles describing the contents of each medium, the version number listed after each program name was current when we published this Bulletin. When you order a distribution tape, diskette, or newer CD-ROM, some of the programs may be newer and therefore the version number higher. See the *note Free Software Foundation Order Form::., for ordering information. Some of the contents of our tape and FTP distributions are compressed. We have software on our tapes and FTP sites to uncompress these files. Due to patent troubles with `compress', we use another compression program, `gzip'. (Such prohibitions on software development are fought by the League for Programming Freedom; *note What Is the LPF::., for details.) GNU `make' is on several of our tapes because some system vendors supply no `make' utility at all and some native `make' programs lack the `VPATH' feature essential for using the GNU configure system to its full extent. The GNU `make' sources have a shell script to build `make' itself on such systems. We welcome all bug reports and enhancements sent to the appropriate electronic mailing list (*note Free Software Support::.). Configuring GNU Software ------------------------ We are using, Autoconf, a uniform scheme for configuring GNU software packages in order to compile them (see "Autoconf" below, in this article). The goal is to have all GNU software support the same alternatives for naming machine and system types. Ultimately, it will be possible to configure and build the entire system all at once, eliminating the need to configure each individual package separately. You can also specify both the host and target system to build cross-compilation tools. Most GNU programs now use Autoconf-generated configure scripts. GNU Software currently available -------------------------------- For future programs and features, see *Note Forthcoming GNUs::. Key to cross reference: BinCD December 1994 Binaries CD-ROM DjgpD Djgpp Diskettes DosBC MS-DOS Book with CD-ROM EmcsD Emacs Diskettes LangT Languages Tape LiteT 4.4BSD-Lite Tape LspEmcT Lisps/Emacs Tape SchmT Scheme Tape SrcCD December 1995 Source CD-ROMs UtilD Selected Utilities Diskettes UtilT Utilities Tape VMSCmpT VMS Compiler Tape VMSEmcsT VMS Emacs Tape WdwsD Windows Diskette X11OptT X11 Optional Tape X11ReqT X11 Required Tape [FSFman] shows that we sell a manual for that package. [FSFrc] shows we sell a reference card for that package. To order them, see the *note Free Software Foundation Order Form::.. *Note Documentation::, for more information on the manuals. Source code for each manual or reference card is included with each package. * `acm' (SrcCD, UtilT) `acm' is a LAN-oriented, multiplayer aerial combat simulation that runs under the X Window System. Players engage in air to air combat against one another using heat seeking missiles and cannons. We are working on a more accurate simulation of real airplane flight characteristics. * apache (SrcCD) Apache is an HTTP server designed as a plug-in replacement for version 1.3 or 1.4 of the NCSA server. It fixes numerous bugs in the NCSA server and includes many frequently requested new features, and has an API which allows it to be extended to meet users' needs more easily. * Autoconf (SrcCD, UtilT) Autoconf produces shell scripts which automatically configure source code packages. These scripts adapt the packages to many kinds of Unix-like systems without manual user intervention. Autoconf creates a script for a package from a template file which lists the operating system features which the package can use, in the form of `m4' macro calls. Autoconf requires GNU `m4' to operate, but the resulting configure scripts it generates do not. * BASH (SrcCD, UtilT) GNU's shell, BASH (Bourne Again SHell), is compatible with the Unix `sh' and offers many extensions found in `csh' and `ksh'. BASH has job control, `csh'-style command history, command-line editing (with Emacs and `vi' modes built-in, and the ability to rebind keys) via the `readline' library. BASH conforms to the POSIX 1003.2-1992 standard. * `bc' (DosBC, SrcCD, UtilT) `bc' is an interactive algebraic language with arbitrary precision numbers. GNU `bc' follows the POSIX 1003.2-1992 standard, with several extensions including multi-character variable names, an `else' statement, and full Boolean expressions. The RPN calculator `dc' is now distributed as part of the same package, but GNU `bc' is not implemented as a `dc' preprocessor. * BFD (BinCD, DjgpD, DosBC, LangT, SrcCD) The Binary File Descriptor library allows a program which operates on object files (e.g., `ld' or GDB) to support many different formats in a clean way. BFD provides a portable interface, so that only BFD needs to know the details of a particular format. One result is that all programs using BFD will support formats such as a.out, COFF, and ELF. BFD comes with Texinfo source for a manual (not yet published on paper). At present, BFD is not distributed separately; it is included with packages that use it. * Binutils (BinCD, DjgpD, DosBC, LangT, SrcCD; `gas' only on VMSCmpT) Binutils includes these programs: `ar', `c++filt', `demangle', `gas', `gprof', `ld', `nlmconv', `nm', `objcopy', `objdump', `ranlib', `size', `strings', & `strip'. Binutils version 2 uses the BFD library. The GNU assembler, `gas', supports the a29k, Alpha, H8/300, H8/500, HP-PA, i386, i960, m68k, m88k, MIPS, NS32K, SH, SPARC, Tahoe, Vax and Z8000 CPUs, and attempts to be compatible with many other assemblers for UNIX and embedded systems. It can produce mixed C-and-assembly listings, and includes a macro facility similar to that in some other assemblers. GNU's linker `ld' emits source-line numbered error messages for multiply-defined symbols and undefined references, and interprets a superset of AT&T's Linker Command Language, which gives control over where segments are placed in memory. `nlmconv' converts object files into Novell NetWare Loadable Modules. `objdump' can disassemble code for most of the CPUs listed above, and can display other data (e.g., symbols and relocations) from any file format read by BFD. * Bison (BinCD,DjgpD,DosBC,LangT,SrcCD,VMSCmpT)[FSFman,FSFrc] Bison is an upwardly compatible replacement for the parser generator `yacc'. Texinfo source for the `Bison Manual' and reference card are included. *Note Documentation::. A recent policy change allows non-free programs to use Bison-generated parsers. *Note Conditions for Using Bison::. * C Library (BinCD, LangT, SrcCD) [FSFman] The GNU C library supports ANSI C-1989, POSIX 1003.1-1990 and most of the functions in POSIX 1003.2-1992. It is upwardly compatible with 4.4BSD and includes many System V functions, plus GNU extensions. The C Library performs many functions of the Unix system calls in the GNU/Hurd. Mike Haertel has written a fast `malloc' which wastes less memory than the old GNU version. The GNU regular-expression functions (`regex' and `rx') now nearly conform to the POSIX 1003.2 standard. GNU `stdio' lets you define new kinds of streams, just by writing a few C functions. The `fmemopen' function uses this to open a stream on a string, which can grow as necessary. You can define your own `printf' formats to use a C function you have written. For example, you can safely use format strings from user input to implement a `printf'-like function for another programming language. Extended `getopt' functions are already used to parse options, including long options, in many GNU utilities. The C Library runs on Sun-3 (SunOS 4.1), Sun-4 (SunOS 4.1 or Solaris 2), HP 9000/300 (4.3BSD), SONY News 800 (NewsOS 3 or 4), MIPS DECstation (Ultrix 4), DEC Alpha (OSF/1), i386/i486/Pentium (System V, SVR4, BSD, SCO 3.2, & SCO ODT 2.0), Sequent Symmetry i386 (Dynix 3), & SGI (Irix 4). *Note Forthcoming GNUs::. Texinfo source for the `GNU C Library Reference Manual' is included (*note Documentation::.. * C++ Library (BinCD, DjgpD, DosBC, LangT, SrcCD) The GNU C++ library (libg++) contains an extensive collection of C++ "forest" classes, an IOStream library for input/output routines, and support tools for use with G++. Supported classes include: Obstacks, multiple-precision Integers and Rationals, Complex numbers, arbitrary length Strings, BitSets, and BitStrings. The distribution also includes the libstdc++ library. This implements library facilities defined by the forthcoming ANSI/ISO C++ standard, including a port of the Standard Template Library. * Calc (DosBC, LspEmcT, SrcCD) [FSFman, FSFrc] Calc (written by Dave Gillespie in Emacs Lisp) is an extensible, advanced desk calculator & mathematical tool that runs as part of GNU Emacs. You can use Calc just as a simple four-function calculator, but it has many more features including: choice of algebraic or RPN (stack-based) entry; logarithmic, trigonometric, & financial functions; arbitrary precision; complex numbers; vectors; matrices; dates; times; infinities; sets; algebraic simplification; differentiation & integration. It outputs to `gnuplot', & comes with source for a manual & reference card (*note Documentation::.). * `cfengine' (SrcCD, UtilT) `cfengine' is used for maintaining site-wide configuration of a heterogeneous Unix network using a simple high level language. Its appearance is similar to `rdist', but also allows many more operations to be performed automatically. See Mark Burgess, "A Site Configuration Engine", `Computing Systems', Vol. 8, No. 3 (ask `office@usenix.org' how to get a copy). * Chess (SrcCD, UtilT, WdwsD) GNU Chess enables most modern computers to play a full game of chess. It supports a plain terminal interface, a curses interface, and a spiffy X Window interface via `xboard'. Improvements this past year include fixes to the game analyzer, book, & hash table; smartening up draw and mate; improved thinking on opponent's time; Autoconf installation; a makefile for Windows NT compilation; forward pruning; unlimited quiescence captures; improved evaluation; improved null & time control logic; & repetition-detection. GNU Chess was originated by Stuart Cracraft. Improvements & rewrites are from John Stanback, Cha Kong Sian, Mike McGann, and many others. Send bugs to `bug-gnu-chess@prep.ai.mit.edu' & general comments to `info-gnu-chess@prep.ai.mit.edu'. * CLISP (LspEmcT, SrcCD) CLISP is a Common Lisp implementation by Bruno Haible and Michael Stoll. It mostly supports the Lisp described by `Common LISP: The Language (2nd edition)' and the ANSI Common Lisp standard. CLISP includes an interpreter, a byte-compiler, a large subset of CLOS, a foreign language interface, and, for some machines, a screen editor. The user interface language (English, German, French) is choosable at run time. Major packages that run in CLISP include CLX & Garnet. CLISP needs only 2 MB of memory & runs on many microcomputers (including MS-DOS systems, OS/2, Windows NT, Amiga 500-4000, Acorn RISC PC) & Unix-like systems (GNU/Linux, Sun4, SVR4, SGI, HP-UX, DEC Alpha, NeXTStep, & others). * Common Lisp **Note Forthcoming GNUs::* (LspEmcT, SrcCD) GNU Common Lisp (GCL, formerly known as Kyoto Common Lisp) is a compiler & interpreter for Common Lisp. GCL is very portable & extremely efficient on a wide class of applications, & compares favorably in performance with commercial Lisps on several large theorem-prover & symbolic algebra systems. GCL supports the CLtL1 specification but is moving towards the proposed ANSI standard. GCL compiles to C & then uses the native optimizing C compiler (e.g., GCC). A function with a fixed number of args & one value turns into a C function of the same number of args, returning one value--so GCL is maximally efficient on such calls. Its conservative garbage collector gives great freedom to the C compiler to put Lisp values in registers. It has a source level Lisp debugger for interpreted code & displays source code in an Emacs window. Its profiler (based on the C profiling tools) counts function calls & the time spent in each function. There is now a built-in interface to the Tk widget system. It runs in a separate process, so users may monitor progress on Lisp computations or interact with running computations via a windowing interface. There is also an Xlib interface via C (xgcl-2)« CLX runs with GCL, as does PCL (see "PCL" later in this article). *Note Forthcoming GNUs::, for plans regarding GCL or for recent developments. GCL version 2.2 is released under the GNU Library General Public License. * CLX (LspEmcT, SrcCD) CLX is an X Window interface library for GCL. * `cpio' (DosBC, SrcCD, UtilD, UtilT) `cpio' is an archive program with all the features of SVR4 `cpio', including support for the final POSIX 1003.1 `ustar' standard. `mt', a program to position magnetic tapes, is included with `cpio'. * CVS (SrcCD, UtilT) CVS, the Concurrent Version System, manages software revision & release control at a multi-developer, multi-directory, multi-group site. It works best with RCS versions 4 and above, but will parse older RCS formats, losing some of CVS's fancier features. (See Berliner, Brian, "CVS-II: Parallelizing Software Development," `Proceedings of the Winter 1990 USENIX Association Conference'; ask `office@usenix.org' how to get a copy.) * DejaGnu (LangT, SrcCD) DejaGnu is a framework to test programs with a single front end for all tests. The framework's flexibility & consistency makes it easy to write tests. DejaGnu comes with `expect', which runs scripts to conduct dialogs with programs. * Diffutils (DjgpD, DosBC, SrcCD, UtilT) GNU `diff' compares files showing line-by-line changes in several flexible formats. It is much faster than traditional Unix versions. The Diffutils package contains `diff', `diff3', `sdiff', & `cmp'. Recent improvements include more consistent handling of character sets and a new `diff' option to do all input/output in binary; this is useful on some non-POSIX hosts. Plans for the Diffutils package include support for internationalization (e.g., error messages in Chinese) and for some non-Unix PC environments. * DJGPP (BinCD, DjgpD, DosBC) DJ Delorie has ported GCC/G++ (see "GCC" in this article) to i386s running MS-DOS. DJGPP has a 32-bit i386 DOS extender with a symbolic debugger; development libraries; & ports of Bison, `flex', & Binutils. Full source code is provided. It needs at least 5MB of hard disk space to install & 512K of RAM to use. It supports SVGA (up to 1024x768), XMS & VDISK memory allocation, `himem.sys', VCPI (e.g., QEMM, DESQview, & 386MAX), & DPMI (e.g., Windows 3.x, OS/2, QEMM, & QDPMI). The FSF offers it on the *Note Compiler Tools Binaries CD-ROM::, and on the *Note DJGPP Diskettes::. FTP from `oak.oakland.edu' in `/simtel/vendors/djgpp/' (or another SimTel mirror site). To join a DJGPP users mailing list, ask `djgpp-request@sun.soe.clarkson.edu'. * `dld' (LangT, SrcCD) `dld' is a dynamic linker written by W. Wilson Ho. Linking your program with the `dld' library allows you to dynamically load object files into the running binary. Currently supported are VAX (Ultrix), Sun 3 (SunOS 3.4 & 4.0), SPARC (SunOS 4.0), Sequent Symmetry (Dynix), & Atari ST. * `doschk' (DosBC, SrcCD, UtilT) This program is a utility to help software developers ensure that their source file names are distinguishable on System V platforms with 14-character filenames and on MS-DOS systems with 8+3 character filenames. * `ecc' (LangT, SrcCD) `ecc' is a Reed-Solomon error correction checking program, which can correct three byte errors in a block of 255 bytes and detect more severe errors. Contact `paulf@stanford.edu' for more information. * `ed' (SrcCD, UtilT) `ed' is the standard text editor. It is line-oriented and can be used interactively or in scripts. * Elib (DosBC, LspEmcT, SrcCD) Elib is a small library of Emacs Lisp functions, including routines for using AVL trees and doubly-linked lists. * Elisp archive (SrcCD) This is a snapshot of Ohio State's GNU Emacs Lisp FTP Archive. FTP it from `archive.cis.ohio-state.edu' in `/pub/gnu/emacs/elisp-archive'. * Emacs **Note Forthcoming GNUs:: for future plans.* In 1975, Richard Stallman developed the first Emacs, an extensible, customizable real-time display editor & computing environment. GNU Emacs is his second implementation. It offers true Lisp--smoothly integrated into the editor--for writing extensions & provides an interface to the X Window System. It runs on Unix, MS-DOS, & Windows NT. In addition to its powerful native command set, Emacs has extensions which emulate the editors vi & EDT (Digital's VMS editor). Emacs has many other features which make it a full computing support environment. Source for the `GNU Emacs Manual' & a reference card comes with the software. Sources for the `GNU Emacs Lisp Reference Manual' & `Programming in Emacs Lisp: An Introduction' are distributed in separate packages. *Note Documentation::. * Emacs 18 (LspEmcT, SrcCD, VMSEmcsT) [FSFrc] Emacs 18.59 is the last release of version 18 from the FSF. We no longer maintain it. It supports these Unix systems that Emacs 19 doesn't support (please help port Emacs 19 to these systems): Alliant FX/80, Altos 3068, Amdahl (UTS), AT&T (3Bs & 7300 PC), CCI 5/32 & 6/32, Celerity, Digital (VAX VMS), Dual, Encore (APC, DPC, & XPC), HLH Orion (original & 1/05), ISI (Optimum V, 80386), Masscomp, NCR Tower 32 (SVR2 & SVR3), Nixdorf Targon 31, Nu (TI & LMI), pfa50, Plexus, Prime EXL, Stride (system rel. 2), Tahoe, Tandem Integrity S2, Tektronix 16000, Triton 88, Ustation E30 (SS5E), Whitechapel (MG1), & Wicat. * Emacs 19 (DosBC, EmcsD, LspEmcT, SrcCD) [FSFman(s), FSFrc] Emacs 19 works with character-only terminals & with the X Window System (with or without an X toolkit). New features in Emacs 19 include: multiple X windows ("frames" to Emacs), with a separate X window for the minibuffer or a minibuffer attached to each X window; property lists associated with regions of text in a buffer; multiple fonts & colors defined by those properties; simplified/improved processing of function keys, mouse clicks, and mouse movement; X selection processing, including clipboard selections; hooks to be run if the point or mouse moves outside a certain range; menu bars and popup menus defined by keymaps; scrollbars; before- and after-change hooks; a source-level debugger for Emacs Lisp programs; floating point numbers; improved buffer allocation, including returning storage to the system when a buffer is killed; interfacing with the X resource manager; many updated libraries; integrated support for version control systems (RCS, CVS, & SCCS); Autoconf based configuration; and support for European character sets. Recent features include the ability to open frames on more than one X display from a single Emacs job, operation on MS-DOS, MS Windows, and Windows NT, displaying multiple views of an outline at the same time, support for the Athena & Motif widgets, version control support for CVS and for multiple branches, text properties for formatting text, commands to edit text properties and save them in files, and GNU-standard long-named command line options. Emacs 19.30 works on: Acorn RISC (RISCiX); Alliant FX/2800 (BSD); Alpha (OSF/1); Apollo (DomainOS); Bull DPX/2 2nn & 3nn (SysV.3) & sps7 (SysV.2); Clipper; Convex (BSD); Cubix QBx (SysV); Data General Aviion (DGUX); DEC MIPS (Ultrix 4.2, OSF/1, not VMS); Elxsi 6400 (SysV); Gould Power Node & NP1 (4.2 & 4.3BSD); Harris Night Hawk 1200, 3000, 4000 & 5000 (cxux); Honeywell XPS100 (SysV); HP 9000 series 200, 300, 700, 800 (but not 500) (4.3BSD; HP-UX 7, 8, 9); Intel i386/i486/Pentium (GNU/Linux, 386BSD, AIX, BSDI/386, FreeBSD, Esix, ISC, MS-DOS (*note MS-DOS Diskettes::., & *Note MS-DOS Book with CD-ROM::), NetBSD, SCO3.2v4, Solaris, SysV, Xenix, WindowsNT); IBM RS/6000 (AIX 3.2) & RT/PC (AIX, BSD); Motorola Delta 147 & 187 (SysV.3, SysV.4, m88kbcs); National Semiconductor 32K (Genix); NeXT (BSD, Mach 2 w/ NeXTStep 3.0); Paragon (OSF/1); Prime EXL (SysV); Pyramid (BSD); Sequent Symmetry (BSD, ptx); Siemens RM400 & RM600 (SysV); SGI Iris 4D (Irix 4.x & 5.x); Sony News/RISC (NewsOS); Stardent i860 (SysV); Sun 3 & 4, SPARC 1, 1+, 2, 10, Classic (SunOS 4.0, 4.1, Solaris 2.0-2.3); Tadpole 68k (SysV); Tektronix XD88 (SysV.3) & 4300 (BSD); & Titan P2 & P3 (SysV). Other configurations supported by Emacs 18 should work with few changes in Emacs 19; as users tell us more about their experiences with different systems, we will augment the list. Also see *Note Forthcoming GNUs::. * `es' (SrcCD, UtilT) `es' is an extensible shell (based on `rc') with first class functions, lexical scope, exceptions and rich return values (i.e., functions can return values other than just numbers). `es''s extensibility comes from the ability to modify and extend the shell's built-in services, such as path searching and redirection. Like `rc', it is great for both interactive use and scripting, particularly since its quoting rules are much less baroque than the C and Bourne shells. * `f2c' (LangT, SrcCD) `f2c' converts Fortran-77 source into C or C++, which can be compiled with GCC or G++. Get bug fixes by FTP from site `netlib.att.com' or by email from `netlib@research.att.com'. See the file `/netlib/f2c/readme.Z' for a summary. Also see the GNU Fortran item later in this article, and in *Note Forthcoming GNUs::. * `ffcall' (SrcCD) `ffcall' is a C library for implementing foreign function calls in embedded interpreters by Bill Triggs and Bruno Haible. It allows C functions with arbitrary argument lists and return types to be called or emulated (callbacks). * Fileutils (DosBC, SrcCD, UtilT) The Fileutils work on files: `chgrp', `chmod', `chown', `cp', `dd', `df', `dir', `du', `install', `ln', `ls', `mkdir', `mkfifo', `mknod', `mv', `rm', `rmdir', `sync', `touch', & `vdir'. * Findutils (DosBC, SrcCD, UtilT) `find' is frequently used both interactively and in shell scripts to find files which match certain criteria and perform arbitrary operations on them. Also included are `locate', which scans a database for file names that match a pattern, and `xargs', which applies a command to a list of files. * Finger (SrcCD, UtilT) GNU Finger has more features than other finger programs. For sites with many hosts, a single host may be designated as the finger "server" host and other hosts at that site configured as finger "clients". The server host collects information about who is logged in on the clients. To finger a user at a GNU Finger site, a query to any of its client hosts gets useful information. GNU Finger supports many customization features, including user output filters and site programmable output for special target names. * `flex' (BinCD, DjgpD, DosBC, LangT, SrcCD, UtilD) [FSFman, FSFrc] `flex' is a replacement for the `lex' scanner generator. `flex' was written by Vern Paxson of the Lawrence Berkeley Laboratory and generates far more efficient scanners than `lex' does. Sources for the `Flex Manual' and reference card are included (*note Documentation::.). * Fortran (`g77') **Note Forthcoming GNUs::* (LangT, SrcCD) GNU Fortran (`g77'), developed by Craig Burley, is available for public beta testing on the Internet. For now, `g77' produces code that is mostly object-compatible with `f2c' & uses the same run-time library (`libf2c'). * Fontutils (SrcCD, UtilT) The Fontutils convert between font formats, create fonts for use with Ghostscript or TeX (starting with a scanned type image & converting the bitmaps to outlines), et al. It includes: `bpltobzr', `bzrto', `charspace', `fontconvert', `gsrenderfont', `imageto', `imgrotate', `limn', & `xbfe'. * GAWK (DosBC, LangT, SrcCD) [FSFman] GAWK is upwardly compatible with the latest POSIX specification of `awk'. It also provides several useful extensions not found in other `awk' implementations. Texinfo source for the `GAWK Manual' comes with the software (*note Documentation::.). * GCC (BinCD, DjgpD, DosBC, LangT, SrcCD, VMSCmpT) [FSFman] Version 2 of the GNU C Compiler supports the languages C, C++, and Objective-C; the source file name suffix or a compiler option selects the language. Objective-C support was donated by NeXT. The runtime support needed to run Objective-C programs is now distributed with GCC (this does not include any Objective-C classes aside from `object', but see "GNUstep" in *Note Forthcoming GNUs::). As much as possible, G++ is kept compatible with the evolving draft ANSI standard, but not with `cfront' (AT&T's compiler), which has been diverging from ANSI. The GNU C Compiler is a fairly portable optimizing compiler which performs automatic register allocation, common sub-expression elimination, invariant code motion from loops, induction variable optimizations, constant propagation and copy propagation, delayed popping of function call arguments, tail recursion elimination, integration of inline functions and frame pointer elimination, instruction scheduling, loop unrolling, filling of delay slots, leaf function optimization, optimized multiplication by constants, a certain amount of common subexpression elimination (CSE) between basic blocks (though not all of the supported machine descriptions provide for scheduling or delay slots), a feature for assigning attributes to instructions, and many local optimizations that are automatically deduced from the machine description. GCC can open-code most arithmetic on 64-bit values (type `long long int'). It supports extended floating point (type `long double') on the 68k; other machines will follow. GCC supports full ANSI C, traditional C, & GNU C extensions (including: nested functions support, nonlocal gotos, & taking the address of a label). GCC can generate a.out, COFF, ELF, & OSF-Rose files when used with a suitable assembler. It can produce debugging information in these formats: BSD stabs, COFF, ECOFF, ECOFF with stabs, & DWARF. GCC generates code for many CPUs, including the a29k, Alpha ARM AT&T DSP1610 Clipper Convex cN Elxsi Fujitsu Gmicro i370, i860, i960, MIL-STD-1750a, MIPS, ns32k, PDP-11, Pyramid, ROMP, RS/6000, SH, SPUR, Tahoe, VAX, & we32k. Position-independent code is generated for the Clipper, Hitachi H8/300, HP-PA (1.0 & 1.1), i386/i486/Pentium, m68k, m88k, SPARC, & SPARClite. Operating systems supported include: GNU/Hurd, GNU/Linux, ACIS, AIX, AOS, BSD, Clix, Concentrix, Ctix, DG/UX, Dynix, FreeBSD, Genix, HP-UX, Irix, ISC, Luna, LynxOS, Minix, NetBSD, NewsOS, NeXTStep, OS/2, OSF, OSF-Rose, RISCOS, SCO, Solaris 2, SunOS 4, System/370, SysV, Ultrix, Unos, VMS, & Windows/NT. Using the configuration scheme for GCC, building a cross-compiler is as easy as building a native compiler. Version 1 of GCC, G++, & libg++ are no longer maintained. Texinfo source for the `Using and Porting GNU CC' manual, is included with GCC (*note Documentation::.). *Note Forthcoming GNUs::, for plans for later releases of GCC. * GDB (BinCD, DjgpD, DosBC, LangT, SrcCD) [FSFman, FSFrc] GDB, the GNU DeBugger, is a source-level debugger for C, C++, & Fortran. GDB can debug both C and C++ programs, and will work with executables produced by many different compilers; however, C++ debugging will have some limitations if you do not use GCC. GDB has a command line user interface, and Emacs has a GDB mode. Two X interfaces (not distributed or maintained by the FSF) are: `gdbtk' (FTP it from `ftp.cygnus.com' in directory `/pub/gdb'); and `xxgdb' (FTP it from `ftp.x.org' in directory `/contrib/utilities'). Executable files and symbol tables are read via the BFD library, which allows a single copy of GDB to debug programs with multiple object file formats (e.g., a.out, COFF, ELF). Other features include a rich command language, remote debugging over serial lines or TCP/IP, and watchpoints (breakpoints triggered when the value of an expression changes). GDB uses a standard remote interface to a simulator library which (so far) has simulators for the Hitachi H8/300, H8/500, Super-H, & Zilog Z8001/2. GDB can perform cross-debugging. To say that GDB "targets" a platform means it can perform native or cross-debugging for it. To say that GDB can "host" a given platform means that it can be built on it, but cannot necessarily debug native programs. GDB can: * "target" & "host": Amiga 3000 (Amix), DEC Alpha (OSF/1), DECstation 3100 & 5000 (Ultrix), HP 9000/300 (BSD, HP-UX), HP 9000/700 (HP-UX 9, 10), i386 (GNU/Hurd, GNU/Linux, BSD, FreeBSD, LynxOS, NetBSD, SCO), IBM RS/6000 (AIX, LynxOS), Motorola Delta m88k (System V, CX/UX), PC532 (NetBSD), Motorola m68k MVME-167 (LynxOS), NCR 3000 (SVR4), SGI (Irix V3, V4, V5), SONY News (NewsOS 3.x), SPARC (LynxOS, NetBSD, Solaris, & SunOS 4.1 ) Sun-3 (SunOS 4.1), & Ultracomputer (a29k running Sym1). * "target", but not "host": AMD 29000 (COFF & a.out), Hitachi H8/300, Hitachi SH, i386 (a.out, COFF, OS/9000), i960 (Nindy, VxWorks), m68k/m68332 (a.out, COFF, VxWorks), MIPS (ELF, IDT ecoff), Fujitsu SPARClite (a.out, COFF), & Z8000. * "host", but not "target": IBM RT/PC (AIX), HP/Apollo 68k (BSD), & Apple Macintosh (MacOS). Sources for the manual, `Debugging with GDB', and a reference card are included (*note Documentation::.). * `gdbm' (LangT, SrcCD, UtilD) `gdbm' is the GNU replacement for the traditional `dbm' and `ndbm' libraries. It implements a database using quick lookup by hashing. `gdbm' does not ordinarily make sparse files (unlike its Unix and BSD counterparts). * `gettext' (LangT, SrcCD) The GNU `gettext' tool set contains everything maintainers need to internationalize a package for messages, tools that help translators localize messages to their native language, once a package has been internationalized. *Note Help the GNU Translation Project::. * Ghostscript (DosBC, SrcCD, UtilT) The GNU release of Ghostscript is an interpreter for the Postscript graphics language (*note Forthcoming GNUs::., for future plans). The current version of GNU Ghostscript is 2.6.2. Features include the ability to use the fonts provided by the platform on which Ghostscript runs (X Window System & Microsoft (MS) Windows), resulting in much better-looking screen displays; improved text file printing (like `enscript'); a utility to extract the text from a Postscript language document; a much more reliable (and faster) MS Windows implementation; support for MS C/C++ 7.0; drivers for many new printers ( e.g. the SPARCprinter), & for TIFF/F (Fax) file format; many more Postscript Level 2 facilities, including most of the color space facilities (but not patterns); & the ability to switch between Level 1 & Level 2 dynamically. Version 2.6.2 adds a LaserJet 4 driver & several important bug fixes to version 2.6.1. Ghostscript executes commands in the Postscript language by writing directly to a printer, drawing on an X window, or writing to files for printing later or manipulating with other graphics programs. Ghostscript includes a C-callable graphics library (for client programs that do not want to deal with the Postscript language). It also supports i386/i486/Pentiums running MS-DOS with EGA, VGA or SuperVGA graphics (but please do *not* ask the FSF staff any questions about this; we do not use MS-DOS). * Ghostview (DosBC, SrcCD, UtilT) Tim Theisen, `ghostview@cs.wisc.edu', created Ghostview, a previewer for multi-page files with an X Window interface. Ghostview & Ghostscript work together; Ghostview creates a viewing window & Ghostscript draws in it. * GIT (SrcCD, UtilT) GIT is a set of interactive tools: an extensible file system browser, an ASCII/hex file viewer, a process viewer/killer, & other related utilities & shell scripts. It can be used to increase the speed & efficiency of many daily tasks, such as copying & moving files & directories, invoking editors, compressing/uncompressing files, creating & expanding archives, compiling programs, sending mail, etc. It looks nice, has colors (if the standard ANSI color sequences are supported), & is user-friendly. * `gmp' **Note Forthcoming GNUs::* (LangT, SrcCD) GNU `mp' is a library for arbitrary precision arithmetic on signed integers and rational numbers. It has a rich set of functions with a regular interface. * GN (SrcCD) GN is a gopher/HTTP server. It recognizes whether the request came from an HTTP (World Wide Web) or gopher client and responds accordingly. * Gnans (SrcCD) Gnans is a program (and language) for the numerical study of deterministic and stochastic dynamical systems. The dynamical systems may evolve in continuous or discrete time. Gnans has graphical & command line interfaces. * GNATS (SrcCD, UtilT) GNATS (GNats: A Tracking System, not to be confused with GNAT, The GNU Ada Translator) is a bug-tracking system. It is based upon the paradigm of a central site or organization which receives problem reports and negotiates their resolution by electronic mail. Although it has been used primarily as a software bug-tracking system so far, it is sufficiently generalized that it could be used for handling system administration issues, project management, or any number of other applications. * `gnuplot' (SrcCD, UtilT, WdwsD) `gnuplot' is an interactive program for plotting mathematical expressions and data. It plots both curves (2 dimensions) & surfaces (3 dimensions). Curiously, it was neither written nor named for the GNU Project; the name is a coincidence. Various GNU programs use `gnuplot'. * `gnuserv' (LspEmcT, SrcCD) `gnuserv' is a enhanced version of Emacs' `emacsclient' program. It lets the user direct a running Emacs to edit files or evaluate arbitrary Emacs Lisp constructs from another process. * GnuGo (SrcCD, UtilT) GnuGo plays the game of Go (Wei-Chi); version 1.2 was released with minor changes for portability, but it is not yet very sophisticated. * `gperf' (LangT, SrcCD) `gperf' generates perfect hash tables. The C version is in package cperf. The C++ version is in libg++. Both produce hash functions in either C or C++. * Graphics (SrcCD, UtilT) GNU Graphics produces x-y plots from ASCII or binary data. It outputs in Postscript, Tektronix 4010 compatible, and Unix device-independent "plot" formats. It has a previewer for the X Window System. Features include a `spline' interpolation program; examples of shell scripts using `graph' and `plot'; a statistics toolkit; and output in TekniCAD TDA and ln03 file formats. Email bugs or queries to Rich Murphey, `Rich@lamprey.utmb.edu'. * grep (DosBC, SrcCD, UtilT) This package has GNU `grep', `egrep', and `fgrep', which find lines that match entered patterns. They are much faster than the traditional Unix versions. * Groff (DjgpD, DosBC, SrcCD, UtilT) Groff is a document formatting system based on a device-independent version of `troff' & includes: `eqn', `nroff', `pic', `refer', `tbl', `troff'; the `man', `ms', & `mm' macros; & drivers for Postscript, TeX `dvi' format, and typewriter-like devices. Groff's `mm' macro package is almost compatible with the DWB `mm' macros with several extensions. Also included is a modified version of the Berkeley `me' macros and an enhanced version of the X11 `xditview' previewer. A driver for the LaserJet 4 series of printers is currently in test. Written in C++, these programs can be compiled with GNU C++ Version 2.5 or later. Groff users are encouraged to contribute enhancements. Most needed are complete Texinfo documentation, a `grap' emulation (a `pic' preprocessor for typesetting graphs), a page-makeup postprocessor similar to `pm' (see `Computing Systems', Vol. 2, No. 2; ask `office@usenix.org' how to get a copy), and an ASCII output class for `pic' to integrate `pic' with Texinfo. Questions and bug reports from users who have read the documentation provided with Groff can be sent to `bug-groff@prep.ai.mit.edu'. * `gzip' (DjgpD, DosBC, LangT, LspEmcT, SrcCD, UtilT) `gzip' can expand LZW-compressed files but uses another, unpatented algorithm for compression which generally produces better results. It also expands files compressed with System V's `pack' program. * `hello' (DosBC, SrcCD, UtilT) The GNU `hello' program produces a familiar, friendly greeting. It allows non-programmers to use a classic computer science tool which would otherwise be unavailable to them. Because it is protected by the GNU General Public License, users are free to share and change it. `hello' is also a good example of a program that meets the GNU coding standards. Like any truly useful program, `hello' contains a built-in mail reader. * `hp2xx' (SrcCD, UtilT) GNU `hp2xx' reads HP-GL files, decomposes all drawing commands into elementary vectors, and converts them into a variety of vector and raster output formats. It is also an HP-GL previewer. Currently supported vector formats include encapsulated Postscript, Uniplex RGIP, Metafont, various special TeX-related formats, and simplified HP-GL (line drawing only) for imports. Raster formats supported include IMG, PBM, PCX, & HP-PCL (including Deskjet & DJ5xxC support). Previewers work under X11 (Unix), OS/2 (PM & full screen), & MS-DOS (SVGA, VGA, & HGC). * HylaFAX (SrcCD, UtilT) HylaFAX (once named FlexFAX) is a facsimile system for Unix systems. It supports sending, receiving, & polled retrieval of facsimile, as well as transparent shared data use of the modem. Details are available on the World Wide Web at: `http://www.vix.com/hylafax/'. * Hyperbole (LspEmcT, SrcCD) Hyperbole, written by Bob Weiner in Emacs Lisp, is an open, efficient, programmable information management & hypertext system, intended for everyday work on any platform supported by Emacs. * `indent' (DosBC, LangT, SrcCD, UtilD) GNU `indent' formats C source code into the GNU indentation style. It also has options to output BSD, K&R, or your own special style. GNU `indent' is more robust & provides more functionality than other such programs, including handling C++ comments. It runs on a number of systems, including DOS & VMS. The next version will also format C++ source code. * Ispell (DosBC, SrcCD, UtilT) Ispell is an interactive spell checker that suggests "near misses" to replace unrecognized words. System & user-maintained dictionaries for multiple languages can be used. Standalone & Emacs interfaces are available. Previously, the FSF had its own version of Ispell ("Ispell 4.0"), but has dropped it for a parallel branch that has had more development ("Ispell 3.1"). (Ispell 3 was an earlier release by the original Ispell author, but others have since made it more sophisticated.) * JACAL *Not available from the FSF except by FTP* JACAL is a symbolic mathematics system for the manipulation and simplification of algebraic equations and expressions. New in JACAL is multivariate factoring from Michael Thomas `(mjt@octavia.anu.edu.au)'. See JACAL's documentation at `http://www-swiss.ai.mit.edu/~jaffer/'. JACAL is written in Scheme using the SLIB portable Scheme Library. It comes with SCM, an IEEE P1178 & R4RS compliant version of Scheme written in C« SCM runs on Amiga, Atari-ST, MS-DOS, OS/2, NOS/VE, Unicos, VMS, Unix, & similar systems. The FSF is not distributing JACAL on any physical media. To get an IBM PC floppy disk with the freely redistributable source & executable files, send $99.00 to: Aubrey Jaffer 84 Pleasant Street Wakefield, MA 01880-1846 USA * `less' (DosBC, SrcCD, UtilD, UtilT) `less' is a display paginator similar to `more' and `pg', but with various features (such as the ability to scroll backwards) that most pagers lack. * `m4' (DosBC, SrcCD, UtilD, UtilT) GNU `m4' is an implementation of the traditional Unix macro processor. It is mostly SVR4 compatible, although it has some extensions (e.g., handling more than 9 positional parameters to macros). `m4' also has built-in functions for including files, running shell commands, doing arithmetic, etc. * `make' (BinCD,DjgpD,DosBC,LangT,LspEmcT,SrcCD,UtilD,UtilT)[FSFman] GNU `make' supports POSIX 1003.2 and has all but a few obscure features of the BSD and System V versions of `make'. GNU extensions include long options, parallel compilation, flexible implicit pattern rules, conditional execution, & powerful text manipulation functions. Texinfo source for the `Make Manual' comes with the program (*note Documentation::.). * MandelSpawn (SrcCD, UtilT) A parallel Mandelbrot generation program for the X Window System. * Midnight Commander (`mc') (SrcCD, UtilT) The Midnight Commander is a user friendly and colorful Unix file manager and shell, useful to novice and guru alike. It has a built-in virtual file system that allows the user to manipulate files inside tar files (both regular and compressed) or files on remote machines using the FTP protocol. * `mkisofs' (SrcCD, UtilT) `mkisofs' is a pre-mastering program to generate an ISO 9660 file system. It takes a snapshot of a directory tree, and makes a binary image which corresponds to an ISO 9660 file system when written to a block device. It can also generate the System Use Sharing Protocol records of the Rock Ridge Interchange Protocol (used to further describe the files in an ISO 9660 file system to a Unix host; it provides information such as longer filenames, uid/gid, permissions, and device nodes). Also included is `cdwrite', which can take an image from `mkisofs' and write it to a Phillips CD recorder system attached to a GNU/Linux system. * mtools (SrcCD, UtilT) mtools is a set of public domain programs to allow Unix systems to read, write, and manipulate files on an MS-DOS file system (usually a diskette). * MULE (DosBC, EmcsD, LspEmcT, SrcCD) MULE is a MULtilingual Enhancement to GNU Emacs. MULE text buffers can contain a mix of characters from many languages including: Japanese, Chinese, Korean, Vietnamese, Thai, modern European languages (including Greek & Russian), Arabic, & Hebrew. MULE also provides input methods for all of them. MULE is being merged into GNU Emacs. *Note GNU & Other Free Software in Japan::, for more information about MULE. * `ncurses' (LangT, SrcCD) `ncurses' is an implementation of the Unix `curses' library for developing screen based programs that are terminal independent. * NetHack (SrcCD, UtilT) NetHack is a Rogue-like adventure game supporting character & X displays. * NIH Class Library (LangT, SrcCD) The NIH Class Library (once known as "OOPS", Object-Oriented Program Support) is a portable collection of C++ classes (similar to those in Smalltalk-80) written in C++ by Keith Gorlen of the National Institutes of Health (NIH). * `nvi' (SrcCD, UtilT) `nvi' is a free implementation of the `vi'/`ex' Unix editor. It has most of the functionality of the original `vi'/`ex', except "open" mode & the `lisp' option, which will be added. Enhancements over `vi'/`ex' include split screens with multiple buffers, handling 8-bit data, infinite file & line lengths, tag stacks, infinite undo, & extended regular expressions. It runs under GNU/Linux, BSD, NetBSD, FreeBSD, BSDI, AIX, HP-UX, DGUX, IRIX, PSF, PTX, Solaris, SunOS, Ultrix, and Unixware, & should port easily to other systems. * Oaklisp (SrcCD) Oaklisp is a fast, portable, object-oriented Scheme with first class types. * Objective-C Library **Note Forthcoming GNUs::* (LangT, SrcCD) Our Objective-C Class Library (`libobjects') has general-purpose, non-graphical Objective-C objects written by Andrew McCallum & other volunteers. It includes collection classes for using groups of objects & C types, I/O streams, coders for formatting objects & C types to streams, ports for network packet transmission, distributed objects (remote object messaging), string classes, exceptions, pseudo-random number generators, & time handling facilities. It also includes the foundation classes for the GNUstep project; over 70 of them have already been implemented. The library is known to work on i386/i486/Pentiums, m68k, SPARC, MIPS, HPPA, & RS/6000. Send queries & bug reports to `mccallum@gnu.ai.mit.edu'. * OBST (LangT, SrcCD) OBST is a persistent object management system with bindings to C++. OBST supports incremental loading of methods. Its graphical tools require the X Window System. It features a hands-on tutorial including sample programs. It compiles with G++, and should install easily on most Unix platforms. * Octave (LangT, SrcCD) Octave is a high-level language similar to MATLAB, primarily intended for numerical computations. It has a convenient command line interface for solving linear & nonlinear problems numerically. Octave does arithmetic for real and complex scalars and matrices, solves sets of nonlinear algebraic equations, integrates systems of ordinary differential & differential-algebraic equations, and integrates functions over finite & infinite intervals. Two- & three-dimensional plotting is available using `gnuplot'. Send queries and bug reports to: `bug-octave@bevo.che.wisc.edu'. Texinfo source is included for a 220+ page Octave manual, not yet published by the FSF. * Oleo (SrcCD, UtilT) Oleo is a spreadsheet program (better for you than the more expensive spreadsheets). It supports the X Window System and character-based terminals, and can output Embedded Postscript renditions of spreadsheets. Keybindings should be familiar to Emacs users and are configurable. Oleo supports multiple variable-width fonts when used under the X Window System or outputting to Postscript devices. * `p2c' (LangT, SrcCD) `p2c' is Dave Gillespie's Pascal-to-C translator. It inputs many different dialects (HP, ISO, Turbo, VAX, et al.) and generates readable, maintainable, portable C. * `patch' (DosBC, SrcCD, UtilT) `patch' is our version of Larry Wall's program to take `diff''s output and apply those differences to an original file to generate the modified version. * PCL (LspEmcT, SrcCD) PCL is a free implementation of a large subset of CLOS, the Common Lisp Object System. It runs under both GCL and CLISP, mentioned above. * `perl' (DosBC, LangT, SrcCD) Larry Wall's `perl' combines the features and capabilities of `sed', `awk', `sh', and C« It also provides interfaces to the Unix system calls and many C library routines. * `pine' (SrcCD, UtilT) `pine' is a friendly menu-driven electronic mail manager and user interface . * `ptx' **Note Forthcoming GNUs::* (SrcCD, UtilD, UtilT) GNU `ptx' is our version of the traditional permuted index generator. It handles multiple input files at once, produces TeX compatible output, and generates readable "KWIC" (KeyWords In Context) indexes without using `nroff'. It does not yet handle input files that do not fit in memory all at once. * `rc' (SrcCD, UtilT) `rc' is a shell that features a C-like syntax (much more so than `csh') and far cleaner quoting rules than the C or Bourne shells. It's intended to be used interactively, but is also great for writing scripts. It inspired the shell `es'. * RCS (SrcCD, UtilD, UtilT) RCS, the Revision Control System, is used for version control & management of software projects. Used with GNU `diff', RCS can handle binary files (executables, object files, 8-bit data, etc). RCS now conforms to GNU configuration standards and to POSIX 1003.1b-1993. Also see the CVS item above. * `recode' **Note Forthcoming GNUs::* (SrcCD, UtilT) GNU `recode' converts files between character sets and usages. When exact transliterations are not possible, it may delete the offending characters or fall back on approximations. This program recognizes or outputs nearly 150 different character sets and is able to transliterate files between almost any pair. Most RFC 1345 character sets are supported. * `regex' (LangT, SrcCD) The GNU regular expression library supports POSIX.2, except for internationalization features. It is included in many GNU programs which do regular expression matching & is available separately. An alternate regular expression package, `rx', is faster than `regex' in most cases & will replace `regex' over time. * `rx' (LangT, SrcCD) Tom Lord has written `rx', a new regular expression library which is faster than the older GNU `regex' library. It is now being distributed with `sed' and `tar'. `rx' will be used in the next releases of `m4' and `ptx'. * SAOimage (SrcCD, UtilT) SAOimage is an X-based astronomical image viewer. It reads data images and displays them with a pseudocolor colormap. There is full interactive control of the colormap, reading, and writing of colormaps, etc. * Scheme *For more information, see *Note Scheme Tape::* (SrcCD, SchmT) * `screen' (SrcCD, UtilT) `screen' is a terminal multiplexer that runs several separate "screens" (ttys) on a single character-based terminal. Each virtual terminal emulates a DEC VT100 plus several ISO 2022 and ISO 6429 (ECMA 48, ANSI X3.64) functions, including color. Arbitrary keyboard input translation is also supported. `screen' sessions can be detached and resumed later on a different terminal type. Output in detached sessions is saved for later viewing. * `sed' (DjgpD, DosBC, SrcCD, UtilD, UtilT) `sed' is a stream-oriented version of `ed'. It comes with the `rx' library. * Sharutils (SrcCD, UtilT) `shar' makes so-called shell archives out of many files, preparing them for transmission by electronic mail services; `unshar' helps unpack these shell archives after reception. `uuencode' and `uudecode' are POSIX compliant implementations of a pair of programs to transform files into a format that can be safely transmitted across a 7-bit ASCII link. * Shellutils (DosBC, SrcCD, UtilT) They are: `basename', `date', `dirname', `echo', `env', `expr', `false', `groups', `hostname', `id', `logname', `nice', `nohup', `pathchk', `printenv', `printf', `pwd', `sleep', `stty', `su', `tee', `test', `true', `tty', `uname', `users', `who', `whoami', & `yes'. * Shogi (SrcCD, UtilT) Shogi is a Japanese game similar to Chess; a major difference is that captured pieces can be returned into play. GNU Shogi is a variant of GNU Chess; it implements the same features & similar heuristics. As a new feature, sequences of partial board patterns can be introduced to help the program play toward specific opening patterns. It has both character and X display interfaces. It is primarily supported by Matthias Mutz on behalf of the FSF. * SIPP (SrcCD) SIPP is a library for creating photorealistic renderings of 3D scenes. A scene is built up of objects which can be transformed with rotation, translation, and scaling. The objects form hierarchies where each object can have arbitrarily many subobjects and subsurfaces. A surface is a number of connected polygons which are rendered with either Phong, Gouraud, or flat shading. The library supports programmable shaders and texture mapping with textures in up to 3 dimensions and automatic interpolation of texture coordinates. A scene can be illuminated by an arbitrary number of light sources. The lights from some of them are capable of casting shadows of objects. * Smalltalk *Also see *Note Forthcoming GNUs::* (LangT,SrcCD) GNU Smalltalk is an interpreted object-oriented programming language system written in highly portable C« It has been ported to many Unix, DOS, & other OSes. Features include a binary image save capability, the ability to call user-written C code with parameters, an Emacs editing mode, a version of the X protocol invocable from Smalltalk, optional byte-code compilation and/or execution tracing, & automatically loaded per-user initialization files. It implements all of the classes & protocol in the book "Smalltalk-80: The Language", except for the graphic user interface (GUI) related classes. * SNePS (SrcCD) SNePS is the Semantic Network Processing System. It is an implementation of a fully intensional theory of propositional knowledge representation and reasoning. SNePS runs under CLISP or GCL. * Spinner (SrcCD) Spinner is a modularized, object oriented, non-forking World Wide Web server with high performance and throughput. * Superopt (LangT, SrcCD) Superopt is a function sequence generator that uses an exhaustive generate-and-test approach to find the shortest instruction sequence for a given function. You provide a function as input, a CPU to generate code for, and how many instructions you want. Its use in GCC is described in the `ACM SIGPLAN PLDI'92 Proceedings'. It supports: SPARC, m68k, m68020, m88k, IBM POWER and PowerPC, AMD 29k, Intel x86 and 960, Pyramid, DEC Alpha, Hitachi SH, & HP-PA. * `tar' (DosBC, SrcCD, UtilT) GNU `tar' includes multi-volume support, the ability to archive sparse files, compression/decompression, remote archives, and special features that allow `tar' to be used for incremental and full backups. GNU `tar' uses an early draft of the POSIX 1003.1 `ustar' format which is different from the final version. This will be corrected in the future. * Termcap Library (SrcCD, UtilT) [FSFman] The GNU Termcap library is a drop-in replacement for `libtermcap.a' on any system. It does not place an arbitrary limit on the size of Termcap entries, unlike most other Termcap libraries. Included is source for the `Termcap Manual' in Texinfo format (*note Documentation::.). * Termutils (SrcCD, UtilT) The Termutils package contains programs for controlling terminals. `tput' is a portable way for shell scripts to use special terminal capabilities. `tabs' is a program to set hardware terminal tab settings. * TeX (DosBC, SrcCD) TeX is a document formatting system that handles complicated typesetting, including mathematics. It is GNU's standard text formatter. The University of Washington maintains & supports a tape distribution of TeX for Unix systems. The core material is Karl Berry's `web2c' TeX package. Sources are available via anonymous ftp; retrieval instructions are in `/pub/tex/unixtex.ftp' on `ftp.cs.umb.edu'. If you receive any installation support from the University of Washington, consider sending them a donation. To order a full distribution written in `tar' on either a 1/4inch 4-track QIC-24 cartridge or a 4mm DAT cartridge, send $210.00 to: Pierre A. MacKay Department of Classics DH-10, Denny Hall 218 University of Washington Seattle, WA 98195 USA Electronic-Mail: `mackay@cs.washington.edu' Telephone: +1-206-543-2268 Please make checks payable to: `University of Washington'. Do not specify any other payee. That causes accounting problems. Checks must be in U.S. dollars, drawn on a U.S. bank. Only prepaid orders can be handled. Overseas sites: please add to the base cost $20.00 to ship via air parcel post or $30.00 to ship via courier. Please check with the above for current prices & formats. * Texinfo (DjgpD,DosBC,LangT,LspEmcT,SrcCD,UtilD,UtilT)[FSFman] Texinfo is a set of utilities (`makeinfo', `info', `texi2dvi', `texindex', `tex2patch', & `fixfonts') which generate both printed manuals & online hypertext documentation (called "Info"), & can read online Info documents. Version 3 has both Emacs Lisp & standalone programs written in C or shell script. Texinfo mode for Emacs enables easy editing & updating of Texinfo files. Source for the `Texinfo Manual' is included (*note Documentation::.). * Textutils (DosBC, SrcCD, UtilT) The Textutils programs manipulate textual data. They include: `cat', `cksum', `comm', `csplit', `cut', `expand', `fmt', `fold', `head', `join', `md5sum', `nl', `od', `paste', `pr', `sort', `split', `sum', `tac', `tail', `tr', `unexpand', `uniq', and `wc'. * Tile Forth (LangT, SrcCD) Tile Forth is a 32-bit implementation of the Forth-83 standard written in C, allowing it to be easily ported to new systems and extended with any C-function (graphics, windowing, etc). Many documented Forth libraries are available, including ones for top-down parsing, multi-threads, & object oriented programming. * `time' (SrcCD, UtilT) `time' reports (usually from a shell) the user, system, & real time used by a process. On some systems it also reports memory usage, page faults, etc. * `ucblogo' (LangT, SrcCD) `ucblogo' implements the classic teaching language, Logo. * UUCP (SrcCD, UtilT) GNU's UUCP system (written by Ian Lance Taylor) supports the `f', `g', `v' (all window & packet sizes), `G', `t', `e', Zmodem, & two new bidirectional (`i' & `j') protocols. With a BSD sockets library, it can make TCP connections. With TLI libraries, it can make TLI connections. Source is included for a manual (not yet published by the FSF). * W3 (LspEmcT, SrcCD) W3 (written by William Perry in Emacs Lisp) is an extensible, advanced World Wide Web browser that runs as part of GNU Emacs. It understands many protocols: FTP, gopher, HTML, SMTP, Telnet, WAIS, et al. * `wdiff' (DosBC, SrcCD, UtilT) `wdiff' is a front-end to GNU `diff'. It compares two files, finding the words deleted or added to the first to make the second. It has many output formats and works well with terminals and pagers. `wdiff' is very useful when two texts differ only by a few words and paragraphs have been refilled. * X11 *For details, see *Note X11 Tapes::* (SrcCD, X11OptT, X11ReqT) * `xboard', `xshogi' (SrcCD, UtilT) `xboard' is an X Window interface to GNU Chess. `xshogi' is an X Window interface to GNU Shogi. They use the R4 Athena widgets and Xt Intrinsics to provide an interactive referee for managing a game between a user & a computer opponent, or between two computers. You can also use `xboard' without GNU Chess to play through games in files or to play through games manually (force mode); in this case, moves aren't validated. * `xgrabsc' (SrcCD) `xgrabsc' is a screen capture program similar to `xwd' but providing more ways of selecting the part of the screen to capture and different types of output: Postscript, color Postscript, xwd, bitmap, pixmap, and puzzle. * `Ygl' (SrcCD, UtilT) `Ygl' emulates a subset of SGI's GL (Graphics Language) library under X11 on GNU/Linux with XFree, AIX 3.2, ConvexOS, HP-UX, SunOS, et al. It has most two-dimensional graphics routines, the queue device & query routines, double buffering, RGB mode with dithering, FORTRAN bindings, at al. ---------------------------------------------------------------------- Forthcoming GNUs **************** Information about the current status of released GNU programs can be found in *Note GNU Software::. Here is some news of future plans. * GNU C Library (For current status, *note GNU Software::..) While there has not been a new release of our C library in some time, a great deal of work is going on; we hope for a new release in the next few months. Much of Roland's recent work has focused on support for GNU/Hurd, where the library does much more work than in Unix (*note What Is the Hurd::.). He has also been working closely with Ulrich Drepper on support for GNU/Linux; we intend a future release of the GNU C library to compatibly supersede the heavily modified version now used with GNU/Linux. The new release will add several new functions traditionally found in Unix systems & some small new GNU extensions, as well as major new internationalization support. Ulrich Drepper has contributed to the library a great deal in the last few months, by writing new floating-point printing/reading functions that are perfectly accurate & much faster than the old code. He has also written a complete set of internationalization features including POSIX.2-compatible `locale' & `localedef' programs, & catalogs for displaying program messages in languages other than English. The library now builds as a shared library for systems that use the ELF object file format. Included is the run-time loader `ld.so' which sets up the shared libraries when a program runs; it works now with the Hurd & Linux kernels, and is easy to port to other ELF systems such as SVR4 & Solaris 2. * GNU Emacs (For current status, *note GNU Software::.) Future versions of Emacs will save the undo history in a file (which allows you to undo older changes in the history), and will also have support for variable-width fonts, wide character sets, and the world's major languages. Our long term plan is to move it in the direction of a WYSIWYG word processor & make it easier for beginners to use. * GNUstep (Also see "Objective-C Library" in *Note GNU Software::) OpenStep is an object-oriented application programming interface specification being proposed as an open object standard. Since its announcement over two years ago, there has been much interest in a GNU implementation, named GNUstep. Work has begun on GNUstep, starting from a library written in Objective-C. Much remains to be done to bring this library close to the OpenStep specifications. Volunteers should contact `office@gnustep.org'. Check `http://www.gnustep.org/gnustep' for more info. * `recode' (For current status, *note GNU Software::.) The next `recode' release should give more flexible control over encodings of charsets, offer MIME conversions, & handle ISO-10646 (Unicode). It will install a library & support files to help work towards internationalizing GNU. * GUILE GNU's Ubiquitous Extension Language is an SCM-based library which programmers can use to make any ordinary C program extensible. (For info on SCM, see "JACAL" in *Note GNU Software::.) GUILE already includes a POSIX.1 interface, an SCSH-like library, a module system, a Tk interface, & a byte-code interpreter; support for Emacs Lisp & a more C-like language is coming. Get snapshots from `ftp.cygnus.com:/pub/lord'. * `ptx' (For current status, *note GNU Software::.) The next release of `ptx' should offer contextualized support for SGML texts, as the first step towards a major overhaul for that package. * GNU Common Lisp (For current status, *note GNU Software::.) Version 2.2 of GNU Common Lisp (GCL) was released in November '95. It now includes a graphical interface to the Tk widget system. All documentation is now Texinfo-based, with built-in regexp matching used to access the documentation. A first pass at the Common Lisp condition system is also included. Some new ports include DEC Alpha and ELF for GNU/Linux. Volunteers to help with the move to the ANSI standard are most welcome; contact `schelter@math.utexas.edu'. * C Interpreter We hope to add interpreter facilities to our compiler and debugger. This task is partly finished. GCC has generated byte code for all supported languages, but that support is in flux at this time. A new effort to finish this work has begun. To make this work usable, we need to enhance GDB to load the byte code dynamically. We would also like support for compiling just a few selected functions in a file. Due to limited resources, the FSF cannot fund this. Interested volunteers should contact `gnu@prep.ai.mit.edu'. * GCC (For current status, *note GNU Software::.) New front ends for GCC are being developed for Pascal and Chill. See the GNU Fortran and GNAT items in this article for news on those front ends. * GNAT: The GNU Ada Translator *Not yet available from the FSF* A front end for much of Ada 95 (GNAT: The GNU Ada Translator) is available via anonymous FTP from `cs.nyu.edu' in `/pub/gnat'. SGI and Digital have chosen GNU Ada as the Ada compiler for certain systems. News about GNAT is posted to the USENET newsgroup `comp.lang.ada'. * GNU Fortran (For info on `f2c' & GCC, *note GNU Software::.) The GNU Fortran (`g77') front end is stable, but work is needed to bring its overall packaging, feature set, & performance up to the levels the Fortran community expects. Tasks to be done include: improving documentation & diagnostics; speeding up compilation, especially for large initialized data tables; implementing `INTEGER*2', `INTEGER*8', & similar features; allowing intrinsics in `PARAMETER' statements; & providing debug information on `COMMON' & `EQUIVALENCE' variables. We don't know when these things will be done, but hope some will be finished in the coming months. You can speed progress by working on them or by offering funding. A mailing list exists for announcements about `g77'. To subscribe, ask `info-gnu-fortran-request@prep.ai.mit.edu'. To contact the developer of `g77' or get current status, write or finger `fortran@gnu.ai.mit.edu'. * Ghostscript (For current status, *note GNU Software::.) Ghostscript 3.0 will be distributed by the FSF soon. It will implement nearly the full Postscript Level 2 language except for LZW compression, which can't be freely implemented because of software patents. (Prohibitions on programming like this are what the League for Programming Freedom is fighting. *Note What Is the LPF::, for details.) * `gmp' (For current status, *note GNU Software::.) The next version of the GNU `mp' library, 2.0, will have arbitrary precision floating point arithmetic, and expanded support for integer and rational number arithmetic. `gmp' 2.0 is up to 4 times faster than previous versions. In particular, the speed of multiplication, division, and GCD has improved. * Smalltalk (For current status, *note GNU Software::.) The next release, version 1.2, will use Autoconf. It will have substantial performance improvements & memory requirement reductions, more control over memory allocation, ability to use the Smalltalk interpreter as a C callable library, better X Window System interfaces, ability to represent and manipulate C data structures in Smalltalk, conditional compilation facilities, large integer support, an advanced GUI-based class browsing system, better TCP/IP interfaces, exception support, weak references, & finalization support. It will run on UNIX, DOS, & Windows NT. * The Dictionary Project The FSF has a copy of the unabridged `Century Dictionary', now in the public domain, and we are planning to put it online. We tried OCR, but it wasn't reliable enough. Russell Nelson is coordinating the project. Volunteers have entered close to fifty pages so far, but the project needs more help; to volunteer, send mail to `dictionary@gnu.ai.mit.edu' or contact the FSF. ---------------------------------------------------------------------- best -gnu@prep.ai.mit.edu Member, League for Programming Freedom, ask: lpf@uunet.uu.net, surf: http://www.lpf.org